//Segundo práctico SOI2012
#include <stdio.h>
#include <string.h>
#include <getopt.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>

#define BUFFSIZE 256

void parsear(char string[],int* ar, char *argv[]);
char * buscar(char p[],char aux[]);
int             haybarra(char p[]);
char *camino_absoluto(char p[],char aux[],char *coman[]);
void modifica_comando(char x[]);

int main(int argc,char *argv[])
{      
        char prompt[BUFFSIZE+1];
        char hostname[BUFFSIZE+1];
        char primera[BUFFSIZE+1];
        char entrada[BUFFSIZE+1];
        char paath[BUFFSIZE+1];
        char aux[BUFFSIZE+1];
        char *comando[BUFFSIZE+1];
        int c=0;
       
       
       // FILE *fd;
       
       
        chdir("/home");
        strcat(prompt,getlogin());
        gethostname(hostname,BUFFSIZE+1);
        strcat(prompt,"@");
        strcat(prompt,hostname);
        strcat(prompt," $ ");
        strcat(prompt,getcwd(NULL,0));
        strcat(prompt,": ");

       
        while(1){
        
        strcpy(*argv,"\0");                                                             // Borramos tanto argc como argv para que cada vez que entre
        argc=0;                                                                                 // no tenga valores guardados anteriormente
                                                               
        paath[0]='\0';
        printf("%s",prompt);                                                    // Mostramos prompt
       
        gets(entrada);                                                                  // Tomamos del stdin y guardamos en entrada
       
        parsear(entrada,&argc,argv);                                    // Llamamos a parsear y le pasamos la entrada, argc y argv[] para que los modifique
       
        if(strcmp(argv[0],"exit")==0)                                   // Si es exit BREAK!!
        {break;
        }
       
        strcpy(primera,argv[0]);                                                                                        // Tomo desde argv el comando y lo pongo en primera
        char k;
        sscanf(primera,"%c",&k);
       
        c = haybarra(primera);
        strcpy(primera,argv[0]);
        printf("ACCESS %s\n",buscar(primera,aux));
        switch(k){
                case '/':                                                                                                       //El 1 caracter es "/".Es camino ABSOLUTO
                strcpy(paath,camino_absoluto(primera,aux,comando));                     // Aquí ya obtenemos el camino absoluto y el comando respectivo
                break;
                case '.':                                                                                                       //El primer caracter es punto
                {sscanf(primera,"%*c" "%c",&k);
                       
                 switch(k){
                         case '.':                                                                                              //El 2 caracter es punto, es
                         {
                          sscanf(primera,"%*c" "%*c" "%c",&k);
                          if(k=='/'){                                                                                   //El 3 carcater es "/".Es camino RELATIVO desde la raiz.
                                  strcpy(primera,strstr(primera,"/"));
                                  strcpy(paath,camino_absoluto(primera,aux,comando));// Aquí ya obtenemos el camino absoluto y el comando respectivo    
                                  if(access(paath,F_OK)==-1){strcpy(paath,"!");}
                                   }                                                                            
                          else{strcpy(paath,"@");}
                                 }
                         break;
                         case '/':													 //El segundo caracter es "/".Es camino RELATIVO. (intenta ejecutar desde donde estoy).
                         {
                          sscanf(primera,"%*c" "%s",primera);
                          strcpy(paath,camino_absoluto(primera,aux,comando));
                          
                         }
                         break;
                         default: /* '?' */
						 strcpy(paath,"@");	
                         break;}
                 break;
                        }
                 default: /* ? */                                           //El 1 caracter no es ni punto ni barra. Es una letra
                 
                 break;
                }
				
				
                printf("paath %s\n",paath);
                printf("comando %s\n",*comando);
/*
        if(k!='/' && k!='.' && !c)                                                                                      // Si el comando no comienza ni con: "/", "." o no tiene "/" en el primer arg
        {strcpy(paath,buscar(primera,aux));}                                                            //Esun comadno directo del PATH. Si el comando esta, devuelve el path.Sino, devuelve "!"
        else
        {if(k=='/')                                                                                                                     // Si es = /, es camino absoluto                        
                {
                        strcpy(paath,camino_absoluto(primera,aux,comando));                     // Aquí ya obtenemos el camino absoluto y el comando respectivo
                }
         else{if(k=='.'){}
                  else{}
                 
         }      
        } */
       
        }
       
        return 0;  
}

void parsear(char string[],int *ar, char *argv[])
{      
        char *palabra[BUFFSIZE+1];

         *palabra = strtok (string," ");                                // Vamos dividiendo el string de entrada para luego cargarlo en el arv[]
                while (*palabra != NULL)                                        // El while va a recorrer hasta el final del string
                {      
                        argv[(*ar)]=*palabra;                                   // Cargamos en argv[] la palabra parseada en el lugar ar que corresponde
                        (*ar)++;                                                                // ar aumenta en cada pasada
                        *palabra = strtok (NULL, " ");                  // Volvemos a buscar
                }      
       
}

char* buscar(char p[],char aux[])
{       char *x[BUFFSIZE+1];
        char cadena[BUFFSIZE+1];
        char *devolver[BUFFSIZE+1];                                                                                                                                                        // chequear luego si el comando está en el PATH
        char *camino[BUFFSIZE+1];
        
        x[0]=getenv("PATH");
		strcpy(cadena,*x);
							// En cadena vamos a tener guardado todo el PATH
        *camino=strtok(cadena,":");                                                                                                                                                     // Guardamos en camino la primer ruta del PATH y luego si no
		devolver[0]=*camino;
        while(*camino !=NULL)                                                                                                                                                           // no lo encuentra en esa posición nos movemos
        {
		strcat(*camino,p);
        if(access(*camino,F_OK)==-1){*camino = strtok (NULL,":");devolver[0]=*camino;}
        else{strcpy(aux,*devolver);
			 return aux;}
        }
        strcpy(aux,"!");
        return aux;
}

int haybarra(char p[])
{       char *b[BUFFSIZE+1];
        *b=strtok(p,"/");
        if(strcmp(p,*b)==0){return 0;}
        else{return 1;}
}

char *camino_absoluto(char p[],char aux[],char *coman[])
{       char *absoluto[BUFFSIZE+1];                                                                                     // Con absoluto recorremos la entrada que es p[]
        char *buf[BUFFSIZE+1];                                                                                          // En cada lugar de buf vamos a guardar lo que está entre barras
       
        int aux2=0;                                                                                                                     // Con aux2 nos movemos dentro del array buf
        int i=0;                                                                                                                        // i para el for
        aux[0]='\0';                                                                                                            // Borramos aux para que cada vez que entre no tenga guardado el paath anterior
       
        *absoluto = strtok (p,"/");                                                                                     // Vamos separando todo p y ademas agregamos a buf
                while (*absoluto != NULL)                                      
                {      
                       
                        buf[aux2]=*absoluto;
                        aux2=aux2+1;
                        *absoluto=strtok(NULL,"/");
                               
                }                                                                                                                               // Sacamos de buf y ponemos en aux con las barras para tener el camino absoluto
               
                for(i=0;i<aux2-1;i++)
                {strcat(aux,"/");
                 strcat(aux,buf[i]);}                                                                                   // Una vez que ya tenemos armado aux, el último valor de buf debe ser guardado en coman
                 aux2=aux2-1;                                                                                                   // ya que ese útlimo valor es el comando.
                coman[0]=buf[aux2];
               
        return aux;
}

